package com.osdp.common.util;


import com.alibaba.fastjson.JSONObject;
import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.osdp.common.exception.PlatformException;
import com.osdp.common.base.JWTInfo;
import lombok.extern.slf4j.Slf4j;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.util.Date;

/**
 *
 */
@Slf4j
public class JWTUtil {

    // 过期时间30分钟
    public static final long EXPIRE_TIME = 2 * 60 * 1000;

    /**
     * 解析token内的可用租户ID，判断是否包含参数的租户ID
     *
     * @param token
     * @param tenantId
     * @return
     */
    public static boolean verifyTenant(String token, String tenantId) {
        return JWTUtil.getInfo(token).getTenants().contains(tenantId);
    }

    /**
     * 校验token是否正确
     *
     * @param token  密钥
     * @param secret 用户的密码
     * @return 是否正确
     */
    public static boolean verify(String token, JWTInfo jwtInfo, String secret) {
        try {
            JWTVerifier info = JWT.require(Algorithm.HMAC256(secret)).withClaim("info", JSONObject.toJSONString(jwtInfo))
                    .build();
            info.verify(token);
            return true;
        } catch (Exception exception) {
            if(log.isErrorEnabled()){
                log.error("发生异常:{}",exception);
            }
            return false;
        }
    }

    /**
     * 获得jwt中的租户ID
     *
     * @return token中包含的用户名
     */
    public static String getTenantId(String token) {
        try {
//            return JwtUtil.getInfo(token).getNowTenant();
            return TokenUtil.getTenantId(token);
        } catch (Exception e) {
            if(log.isErrorEnabled()){
                log.error(e.getMessage(),e);
            }
            return null;
        }
    }

    /**
     * 获得jwt中的username
     *
     * @return token中包含的用户名
     */
    public static String getUserName(String token) {
        try {
//            return JwtUtil.getInfo(token).getUserName();
            return TokenUtil.getUserName(token);
        } catch (Exception e) {
            if(log.isErrorEnabled()){
                log.error(e.getMessage(),e);
            }
            return null;
        }
    }

    /**
     * 获得jwt中的用户id
     *
     * @return token中包含的用户名
     */
    public static String getUserId(String token) {
        try {
//            return JwtUtil.getInfo(token).getUserId();
            return TokenUtil.getUserId(token);
        } catch (Exception e) {
            if(log.isErrorEnabled()){
                log.error(e.getMessage(),e);
            }
            return e.getMessage();
        }
    }

    /**
     * 生成签名,5min后过期
     *
     * @param userid   用户id
     * @param username 用户名
     * @param tenantid 租户id
     * @param secret   用户的密码
     * @return 加密的token
     */
    @Deprecated
    public static String sign(String userid, String username, String tenantid, String secret) {
        Date date = new Date(System.currentTimeMillis() + EXPIRE_TIME);
        Algorithm algorithm = Algorithm.HMAC256(secret);
        // 附带username信息
        return JWT.create().withClaim("userid", userid).withClaim("username", username).withClaim("tenantid", tenantid).withExpiresAt(date).sign(algorithm);

    }

    /**
     * 生成签名 新方法，info内为json字符串，包括用户分别拥有什么租户下，租户下分别是什么角色，可继续扩展
     *
     * @param info
     * @param secret
     * @return
     */
//    public static String sign(JWTInfo info, String secret) {
//        Date date = new Date(System.currentTimeMillis() + EXPIRE_TIME);
//        Algorithm algorithm = Algorithm.HMAC256(secret);
//        return JWT.create().withClaim("info", JSONObject.toJSONString(info)).withExpiresAt(date).sign(algorithm);
//    }

    /**
     * 生成签名 新方法，info内为json字符串，包括用户分别拥有什么租户下，租户下分别是什么角色，可继续扩展
     *
     * @param info
     * @param secret
     * @return
     */
    public static String sign(JWTInfo info, String secret) {
        Algorithm algorithm = Algorithm.HMAC256(secret);
        return JWT.create().withClaim("info", JSONObject.toJSONString(info)).sign(algorithm);
    }

    /**
     * 获得jwt中的info信息
     */
    public static JWTInfo getInfo(String token) {
        return TokenUtil.getJwtInfo(token);
//        try {
//            DecodedJWT jwt = JWT.decode(token);
//            String s = jwt.getClaim("info").asString();
//            JSONObject object = JSONObject.parseObject(s);
//            JWTInfo info = new JWTInfo(object.getString("userId"), object.getString("userName"), object.getBoolean("superAdmin"), object.getString("nowTenant"));
//            List<String> l = object.getObject("tenants", ArrayList.class);
//            info.setTenants(l);
//            return info;
//        } catch (JWTDecodeException e) {
//            if(log.isErrorEnabled()){
//                log.error(String.format("发生异常：%s,详细信息：%s", e.getMessage(), ExceptionUtil.getMessage(e)));
//            }
//            return null;
//        }
    }

    /**
     * 根据request中的token获取用户账号
     *
     * @param request
     * @return
     * @throws PlatformException
     */
    public static String getUserNameByToken(HttpServletRequest request) throws PlatformException {
        String accessToken = request.getHeader("X-Access-Token");
        String username = getUserName(accessToken);
        if (ConvertUtil.isEmpty(username)) {
            throw new PlatformException("未获取到用户");
        }
        return username;
    }

    /**
     * 从session中获取变量
     *
     * @param key
     * @return
     */
    public static String getSessionData(String key) {
        //${myVar}%
        //得到${} 后面的值
        String moshi = "";
        if (key.indexOf("}") != -1) {
            moshi = key.substring(key.indexOf("}") + 1);
        }
        String returnValue = null;
        if (key.contains("#{")) {
            key = key.substring(2, key.indexOf("}"));
        }
        if (ConvertUtil.isNotEmpty(key)) {
            HttpSession session = SpringContextUtil.getHttpServletRequest().getSession();
            returnValue = (String) session.getAttribute(key);
        }
        //结果加上${} 后面的值
        if (returnValue != null) {
            returnValue = returnValue + moshi;
        }
        return returnValue;
    }

    /**
     * 从当前用户中获取变量
     *
     * @param key
     * @param user
     * @return
     */
//    public static String getUserSystemData(String key, SysUserCacheInfo user) {
//        if (user == null) {
//            user = DataAutorUtil.loadUserInfo();
//        }
//        //#{sys_user_code}%
//        String moshi = "";
//        if (key.indexOf("}") != -1) {
//            moshi = key.substring(key.indexOf("}") + 1);
//        }
//        String returnValue = null;
//        //针对特殊标示处理#{sysOrgCode}，判断替换
//        if (key.contains("#{")) {
//            key = key.substring(2, key.indexOf("}"));
//        }
//        //替换为系统登录用户帐号
//        if (key.equals(DataBaseConstant.SYS_USER_ID) || key.equals(DataBaseConstant.SYS_USER_ID_TABLE)) {
//            returnValue = user.getSysUserId();
//        }
//        //替换为系统登录用户真实名字
//        if (key.equals(DataBaseConstant.SYS_USER_NAME) || key.equals(DataBaseConstant.SYS_USER_NAME_TABLE)) {
//            returnValue = user.getSysUserName();
//        }
//        //替换为系统用户登录所使用的部门ID
//        if (key.equals(DataBaseConstant.SYS_ORG_ID) || key.equals(DataBaseConstant.SYS_ORG_ID_TABLE)) {
//            returnValue = user.getSysOrgId();
//        }
//        //替换为系统用户登录所使用的部门ID
//        if (key.equals(DataBaseConstant.SYS_ORG_ID_AND_CHILD) || key.equals(DataBaseConstant.SYS_ORG_ID_AND_CHILD_TABLE)) {
//            returnValue = user.getSysOrgIdAndChild();
//        }
//        //替换为系统用户登录所使用的机构编码
//        if (key.equals(DataBaseConstant.SYS_ORG_CODE) || key.equals(DataBaseConstant.SYS_ORG_CODE_TABLE)) {
//            returnValue = user.getSysOrgCode();
//        }
//        //替换为系统用户所拥有的所有机构编码
//        if (key.equals(DataBaseConstant.SYS_MULTI_ORG_CODE)) {
//            if (user.isOneDepart()) {
//                returnValue = user.getSysMultiOrgCode().get(0);
//            } else {
//                returnValue = Joiner.on(",").join(user.getSysMultiOrgCode());
//            }
//        }
//        //替换为当前系统时间(年月日)
//        if (key.equals(DataBaseConstant.SYS_DATE) || key.equals(DataBaseConstant.SYS_DATE_TABLE)) {
//            returnValue = user.getSysDate();
//        }
//        //替换为当前系统时间（年月日时分秒）
//        if (key.equals(DataBaseConstant.SYS_TIME) || key.equals(DataBaseConstant.SYS_TIME_TABLE)) {
//            returnValue = user.getSysTime();
//        }
//        //流程状态默认值（默认未发起）
//        if (key.equals(DataBaseConstant.BPM_STATUS) || key.equals(DataBaseConstant.BPM_STATUS_TABLE)) {
//            returnValue = "1";
//        }
//        if (returnValue != null) {
//            returnValue = returnValue + moshi;
//        }
//        return returnValue;
//    }
}
